home *** CD-ROM | disk | FTP | other *** search
/ Aminet 2 / Aminet AMIGA CDROM (1994)(Walnut Creek)[Feb 1994][W.O. 44790-1].iso / Aminet / gfx / edit / TSMrph23s.lha / TSM23s.lha / RGBToScreen020.c < prev    next >
C/C++ Source or Header  |  1993-10-08  |  7KB  |  301 lines
  1. // TSMorph - Amiga Morphing program
  2. // Copyright (C) © 1993  Topicsave Limited
  3.  
  4. // This program is free software; you can redistribute it and/or modify
  5. // it under the terms of the GNU General Public License as published by
  6. // the Free Software Foundation; either version 2 of the License, or
  7. // any later version.
  8.  
  9. // This program is distributed in the hope that it will be useful,
  10. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. // GNU General Public License for more details.
  13.  
  14. // You should have received a copy of the GNU General Public License
  15. // along with this program; if not, write to the Free Software
  16. // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  
  18. // mpaddock@cix.compulink.co.uk
  19.  
  20. //    $Author: M_J_Paddock $
  21. //    $Date: 1992/08/08 01:09:39 $
  22. //    $Revision: 1.2 $
  23.  
  24. // include precompiled code if required
  25. #ifndef TSMORPH_H
  26. #include "TSMorph.h"
  27. #endif
  28.  
  29. // The two functions in this file are exact clones of those in OpalLoad.c
  30. // but This code is compiled with -m2 -O -mt
  31. // and is only called if at least a 020 is present
  32.  
  33. void
  34. RGBToScreen020(UBYTE *red,UBYTE *green,UBYTE *blue,UWORD Height,UWORD Width,
  35.                           UWORD maxcol,UWORD xadd,UBYTE *r,UBYTE *g,UBYTE *b) {
  36.     UWORD i,j,k;
  37.     ULONG maxdiff;
  38.     ULONG diff;
  39.     LONG t;
  40.     UWORD index;
  41.  
  42.     for (j = 0;
  43.           j < Height;
  44.           ++j) {
  45.         if (ProgressWnd) {
  46.           GT_SetGadgetAttrs(ProgressGadgets[GDX_Pass2],ProgressWnd,NULL,
  47.                                      GTSL_Level,(ULONG)j,TAG_END);
  48.             HandleProgressIDCMP();
  49.        }
  50.         for (i = 0;
  51.               i < Width;
  52.               ++i) {
  53.             // Find closest color
  54.             maxdiff = 0x7FFFFFFF;
  55.             for (k = 0;
  56.                   k < maxcol;
  57.                   ++k) {
  58.                 t = *red - r[k];
  59.                 diff = t*t*3;
  60.                 t = *green - g[k];
  61.                 diff += (t*t*6);
  62.                 t = *blue - b[k];
  63.                 diff += (t*t);
  64.                 if (diff < maxdiff) {
  65.                     maxdiff = diff;
  66.                     index = k;
  67.                 }
  68.             }
  69.             // Store index to color
  70.             *red = index;
  71.             ++red;
  72.             ++green;
  73.             ++blue;
  74.         }
  75.         red += xadd;
  76.         green += xadd;
  77.         blue += xadd;
  78.         if (ProgressWnd) {
  79.             HandleProgressIDCMP();
  80.         }
  81.     }
  82. }
  83.  
  84. void
  85. PaletteToScreen020(struct RastPort *Rp,struct Picture *pic,UWORD maxcol,
  86.                                 UBYTE *r,UBYTE *g,UBYTE *b) {
  87.     UWORD                    i,j,k;            // loop counters
  88.     LONG                    penno;
  89.     UBYTE                    rr,gg,bb;
  90.     ULONG maxdiff;
  91.     ULONG diff;
  92.     UWORD index;
  93.     LONG                    t;                    // temp diff
  94.     UWORD EHB;
  95.     BOOL isHAM6 = FALSE;
  96.     BOOL isHAM8 = FALSE;
  97.     BOOL isEHB = FALSE;
  98.     struct DisplayInfo queryinfo;
  99.     DisplayInfoHandle handle;
  100.     struct BitMap         BM;
  101.     UBYTE *arrayp;
  102.  
  103.    InitBitMap(&BM,pic->ilbm->Bmhd.nPlanes,pic->ilbm->Bmhd.w,pic->ilbm->Bmhd.h);
  104.       RP.BitMap = &BM;
  105.    InitBitMap(&TBM,pic->ilbm->Bmhd.nPlanes,pic->ilbm->Bmhd.w,1);
  106.    TRP.BitMap = &TBM;
  107.    TBM.Planes[0]=plane0;
  108.    TBM.Planes[1]=plane1;
  109.    TBM.Planes[2]=plane2;
  110.       TBM.Planes[3]=plane3;
  111.    TBM.Planes[4]=plane4;
  112.    TBM.Planes[5]=plane5;
  113.    TBM.Planes[6]=plane6;
  114.    TBM.Planes[7]=plane7;
  115.  
  116.     if ((handle = FindDisplayInfo(pic->ilbm->camg)) &&
  117.          (GetDisplayInfoData(handle,(UBYTE *)&queryinfo,sizeof(queryinfo),DTAG_DISP,NULL))) {
  118.         if ((pic->ilbm->Bmhd.nPlanes == 6) && (queryinfo.PropertyFlags & DIPF_IS_HAM)) {
  119.            GT_SetGadgetAttrs(ProgressGadgets[GDX_Mess],ProgressWnd,NULL,
  120.                                      GTTX_Text,(ULONG)"Remapping HAM6 palette",
  121.                                     TAG_END);
  122.             isHAM6 = TRUE;
  123.         }
  124.         else {
  125.             if ((pic->ilbm->Bmhd.nPlanes == 8) && (queryinfo.PropertyFlags & DIPF_IS_HAM)) {
  126.                 isHAM8 = TRUE;
  127.                GT_SetGadgetAttrs(ProgressGadgets[GDX_Mess],ProgressWnd,NULL,
  128.                                      GTTX_Text,(ULONG)"Remapping HAM8 palette",
  129.                                     TAG_END);
  130.             }
  131.             else {
  132.                   if ((pic->ilbm->Bmhd.nPlanes == 6) && (queryinfo.PropertyFlags & DIPF_IS_EXTRAHALFBRITE)) {
  133.                       isEHB = TRUE;
  134.                    GT_SetGadgetAttrs(ProgressGadgets[GDX_Mess],ProgressWnd,NULL,
  135.                                                    GTTX_Text,(ULONG)"Remapping EHB palette",
  136.                                                 TAG_END);
  137.                   }
  138.                   else {
  139.                    GT_SetGadgetAttrs(ProgressGadgets[GDX_Mess],ProgressWnd,NULL,
  140.                                               GTTX_Text,(ULONG)"Remapping ILBM palette",
  141.                                             TAG_END);
  142.                   }
  143.             }
  144.         }
  145.     }
  146.     for (j = 0;
  147.          j < pic->ilbm->Bmhd.h;
  148.          ++j) {
  149.         if (ProgressWnd) {
  150.           GT_SetGadgetAttrs(ProgressGadgets[GDX_Pass2],ProgressWnd,NULL,
  151.                               GTSL_Level,(ULONG)j,TAG_END);
  152.             HandleProgressIDCMP();
  153.           }
  154.           ReadPixelLine8(Rp,0,j,pic->ilbm->Bmhd.w,Array,&TRP);
  155.           arrayp = Array;
  156.         if (isHAM6) {
  157.               rr = gg = bb = 0;
  158.            for (i = 0;
  159.                     i < pic->ilbm->Bmhd.w;
  160.                  ++i) {
  161.                penno = *arrayp;
  162.                switch (penno & 0x30) {
  163.                case 0:
  164.                    rr = pic->ilbm->RGB[penno*4+1];
  165.                    gg = pic->ilbm->RGB[penno*4+2];
  166.                    bb = pic->ilbm->RGB[penno*4+3];
  167.                    break;
  168.                case 0x10:
  169.                    bb = (penno&0xf)|((penno&0xf)<<4);
  170.                    break;
  171.                case 0x20:
  172.                    rr = (penno&0xf)|((penno&0xf)<<4);
  173.                    break;
  174.                case 0x30:
  175.                    gg = (penno&0xf)|((penno&0xf)<<4);
  176.                    break;
  177.                }
  178.                 // Find closest color
  179.                 maxdiff = 0x7FFFFFFF;
  180.                 for (k = 0;
  181.                       k < maxcol;
  182.                       ++k) {
  183.                     t = rr - r[k];
  184.                     diff = t*t*3;
  185.                     t = gg - g[k];
  186.                     diff += (t*t*6);
  187.                     t = bb - b[k];
  188.                     diff += (t*t);
  189.                     if (diff < maxdiff) {
  190.                         maxdiff = diff;
  191.                         index = k;
  192.                     }
  193.                 }
  194.                 *arrayp++ = index;
  195.             }
  196.           }
  197.           else {
  198.               if (isHAM8) {
  199.                 rr = gg = bb = 0;
  200.                for (i = 0;
  201.                         i < pic->ilbm->Bmhd.w;
  202.                      ++i) {
  203.                    penno = *arrayp;
  204.                    switch (penno & 0xc0) {
  205.                    case 0:
  206.                        rr = pic->ilbm->RGB[penno*4+1];
  207.                        gg = pic->ilbm->RGB[penno*4+2];
  208.                        bb = pic->ilbm->RGB[penno*4+3];
  209.                        break;
  210.                    case 0x40:
  211.                        bb = (penno&0x3f)<<2;
  212.                        break;
  213.                    case 0x80:
  214.                        rr = (penno&0x3f)<<2;
  215.                        break;
  216.                    case 0xc0:
  217.                        gg = (penno&0x3f)<<2;
  218.                        break;
  219.                    }
  220.                     // Find closest color
  221.                     maxdiff = 0x7FFFFFFF;
  222.                     for (k = 0;
  223.                           k < maxcol;
  224.                           ++k) {
  225.                         t = rr - r[k];
  226.                         diff = t*t*3;
  227.                         t = gg - g[k];
  228.                         diff += (t*t*6);
  229.                         t = bb - b[k];
  230.                         diff += (t*t);
  231.                         if (diff < maxdiff) {
  232.                             maxdiff = diff;
  233.                             index = k;
  234.                         }
  235.                     }
  236.                     *arrayp++ = index;
  237.                 }
  238.               }
  239.               else {
  240.                   if (isEHB) {
  241.                    for (i = 0;
  242.                             i < pic->ilbm->Bmhd.w;
  243.                          ++i) {
  244.                        penno = *arrayp;
  245.                        EHB = (penno & 0x20)?1:0;
  246.                        penno &= 0x1f;
  247.                        rr = pic->ilbm->RGB[penno*4+1]>>EHB;
  248.                        gg = pic->ilbm->RGB[penno*4+2]>>EHB;
  249.                        bb = pic->ilbm->RGB[penno*4+3]>>EHB;
  250.                         // Find closest color
  251.                         maxdiff = 0x7FFFFFFF;
  252.                         for (k = 0;
  253.                               k < maxcol;
  254.                               ++k) {
  255.                             t = rr - r[k];
  256.                             diff = t*t*3;
  257.                             t = gg - g[k];
  258.                             diff += (t*t*6);
  259.                             t = bb - b[k];
  260.                             diff += (t*t);
  261.                             if (diff < maxdiff) {
  262.                                 maxdiff = diff;
  263.                                 index = k;
  264.                             }
  265.                         }
  266.                         *arrayp++ = index;
  267.                     }
  268.                   }
  269.                   else {
  270.                    for (i = 0;
  271.                             i < pic->ilbm->Bmhd.w;
  272.                          ++i) {
  273.                        penno = *arrayp;
  274.                        rr = pic->ilbm->RGB[penno*4+1];
  275.                        gg = pic->ilbm->RGB[penno*4+2];
  276.                        bb = pic->ilbm->RGB[penno*4+3];
  277.                         // Find closest color
  278.                         maxdiff = 0x7FFFFFFF;
  279.                         for (k = 0;
  280.                               k < maxcol;
  281.                               ++k) {
  282.                             t = rr - r[k];
  283.                             diff = t*t*3;
  284.                             t = gg - g[k];
  285.                             diff += (t*t*6);
  286.                             t = bb - b[k];
  287.                             diff += (t*t);
  288.                             if (diff < maxdiff) {
  289.                                 maxdiff = diff;
  290.                                 index = k;
  291.                             }
  292.                         }
  293.                         *arrayp++ = index;
  294.                     }
  295.                 }
  296.             }
  297.        }
  298.        WritePixelLine8(Rp,0,j,pic->ilbm->Bmhd.w,Array,&TRP);
  299.     }
  300. }
  301.